Работа с ИИ-моделями

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ

Всем

Работа с ИИ-моделями

Основная цель работы с моделью — правильно её загрузить, настроить окружение, определить параметры генерации и организовать взаимодействие между пользователем (или системой) и моделью. Это может происходить как через облачные API, так и локально, без подключения к интернету.

Да, именно локально - просто загрузить себе модель, настроить её и использовать возможности ИИ без доступа к сети!

Локальное развёртывание моделей

Как запускать модель локально

Локальный запуск ИИ-модели обеспечивает:

Полный контроль над данными: никакая информация не покидает ваше устройство.
Автономность: работа возможна даже при отсутствии интернета.
Гибкость: можно изменять параметры, использовать собственные промпты, интегрировать в свои приложения.
Приватность: особенно важно при работе с конфиденциальными документами, исходным кодом, внутренними базами знаний.

Для этого требуется загрузить веса модели (обычно в формате GGUF, safetensors или .bin), выбрать подходящий движок (например, llama.cpp, Ollama, LM Studio) и обеспечить достаточные вычислительные ресурсы. GPU-ускорение поддерживается только для совместимых видеокарт (NVIDIA с поддержкой CUDA).

Самый простой и безопасный способ - установить на компьютер программу LM Studio, загрузить и подключить модель...и работать абсолютно так же, как и с официальными онлайн-версиями чат-ботов.

Перед началом работы обязательно проверьте ресурсы компьютера. Чтобы не перегружать систему, не используйте без необходимости слишком тяжелые модели, начните с простых - к примеру, при первом запуске LM Studio предложить установить модель от Google, и можно будет потестировать сразу её. Контекстное окно ограничено (обычно 4K–32K токенов в зависимости от модели).

В LM Studio можно воспользоваться поиском, и выбрать сразу готовые модели. При загрузке модели сохранятся в локальном хранилище приложения (поэтому лучше в параметрах сразу выбрать место хранения моделей с диском побольше).

При первом запуске модель загружается в оперативную память и будет занимать 10-60 секунд. При закрытии приложения модель выгружается из памяти — при следующем запуске потребуется повторная загрузка. Избегайте одновременной загрузки нескольких моделей — это быстро исчерпает оперативную память.

Для интеграции с кодом запускайте локальный сервер - LM Studio это умеет.

Бесплатно

Использование локальных моделей через LM Studio бесплатно в плане прямых платежей за запросы, но есть важные нюансы, которые необходимо учитывать.

Аспект	Статус
Само приложение LM Studio (Desktop)	Бесплатно для личного использования
Загрузка моделей из встроенного каталога	Бесплатно (трафик оплачивается вашим провайдером)
Количество запросов к локальной модели	Неограниченно, без подписки
Отсутствие передачи данных на серверы	Полная локальность — данные не покидают ваш компьютер

Большинство популярных моделей распространяются под лицензиями с условиями:

Модель / Поставщик	Лицензия	Коммерческое использование	Ограничения
Llama 3 / Llama 3.1 (Meta)	Llama Community License	Разрешено при соблюдении условий	Запрещено обучение на выходных данных модели для улучшения других LLM; требуется >700M MAU для уведомления Meta
Mistral / Mixtral (Mistral AI)	Apache 2.0 + дополнительные условия	Разрешено	Аналогичные ограничения на обучение
Qwen (Alibaba)	Tongyi Qianwen LICENSE	Разрешено с условиями	Требуется согласие для очень крупных развёртываний
Phi-3 (Microsoft)	MIT	Разрешено	Минимальные ограничения
Command R+ (Cohere)	CC-BY-NC 4.0	Запрещено без коммерческой лицензии	Только некоммерческое использование

Для личного использования (включая обучение, эксперименты, написание кода для себя) ограничения практически не влияют. Проблемы возникают при:

Интеграции модели в коммерческий продукт/сервис

Предоставлении доступа третьим лицам за плату

Массовом развёртывании без соблюдения условий лицензии

Требования к оборудованию

Оперативная память (RAM)

Минимальный объём оперативной памяти зависит от размера модели:

Модель 3B (3 миллиарда параметров): ~6–8 ГБ RAM
Модель 7B: ~12–16 ГБ RAM
Модель 13B: ~24–32 ГБ RAM
Модель 70B: 64+ ГБ RAM (часто требует GPU)

Если используется только CPU, вся модель загружается в оперативную память. При использовании GPU часть весов может храниться в видеопамяти.

Видеопамять (VRAM)

GPU значительно ускоряет генерацию. Для комфортной работы:

7B модель в 4-битном квантовании: ~6 ГБ VRAM
13B модель: ~10–12 ГБ VRAM
70B модель: 24+ ГБ VRAM (например, NVIDIA A100, RTX 4090)

Модели с квантованием (например, Q4_K_M) требуют меньше памяти, но немного теряют в точности.

Свободное место на диске

Веса моделей занимают от 2 ГБ (для 3B) до 40+ ГБ (для 70B в FP16). После квантования размер уменьшается:

Llama-3-8B-Q4_K_M.gguf ≈ 4.7 ГБ
Mistral-7B-Instruct-v0.3-Q5_K_M.gguf ≈ 5.2 ГБ

Также требуется место для временных файлов, кэша эмбеддингов, векторных баз данных.

Квантование и GPU-ускорение

Что такое квантование

Квантование — это техника снижения точности чисел, представляющих веса нейросети. Вместо 16-битных (float16) или 32-битных (float32) чисел используются 4-битные (int4) или 5-битные (int5) представления.

Преимущества:

Уменьшение размера модели в 3–4 раза
Снижение требований к RAM/VRAM
Возможность запуска больших моделей на потребительских устройствах

Недостатки:

Незначительное снижение качества ответов
Потеря в сложных рассуждениях или точных вычислениях

Форматы квантования в llama.cpp:

Q4_0 — базовое 4-битное квантование
Q4_K_M — улучшенное, сохраняет больше информации в ключевых весах
Q5_K_S, Q6_K — более точные, но крупнее

Выбор формата — баланс между производительностью и качеством.

GPU-ускорение

Современные фреймворки (llama.cpp, vLLM, text-generation-webui) поддерживают частичную или полную загрузку модели на GPU. Это достигается через библиотеки CUDA (NVIDIA) или Metal (Apple).

Пример: запуск llama.cpp с использованием GPU:

./main -m models/llama-3-8b.Q5_K_M.gguf -n 512 --gpu-layers 35

Параметр --gpu-layers 35 указывает, сколько слоёв нейросети загрузить в видеопамять. Чем больше — тем быстрее генерация, но выше требования к VRAM.

Понятия

Что такое токен

Токен — минимальная единица текста, которую модель обрабатывает. Это может быть слово, подслово или символ.

Примеры:

Слово "hello" → 1 токен
Слово "привет" → 1 токен
"unbelievable" → ["un", "believ", "able"] → 3 токена
Число "2025" → 1 токен
Пробел или знак препинания — часто отдельный токен

Модели работают не с буквами, а с токенами. Скорость генерации измеряется в токенах в секунду (tokens/sec). На CPU — 2–10 токенов/сек, на мощном GPU — 50–200+.

Контекстное окно

Контекстное окно — максимальное количество токенов, которые модель может одновременно "помнить" при генерации. Это сумма входного запроса и выходного ответа.

Примеры:

Llama-3-8B: 8192 токенов
Mistral-7B: 32768 токенов
Claude 3.5 Sonnet: 200 000 токенов
Gemini 1.5 Pro: до 2 000 000 токенов

Если ваш документ длиннее контекстного окна, его нужно разбивать на части или использовать RAG (см. ниже).

Что означает "7B", "70B"

Буква B означает миллиард параметров (billion). Это количество обучаемых весов в нейросети.

3B — лёгкая модель, подходит для мобильных устройств, простых задач
7B–13B — золотая середина: хорошее качество, запускается на RTX 3060–4090
34B–70B — высокое качество, требует серверного оборудования или нескольких GPU
>100B — обычно доступны только через облачные API (GPT-4, Claude Opus)

Больше параметров ≠ всегда лучше. Архитектура, качество данных и обучение играют ключевую роль.

Как скачивать и устанавливать локальные модели

Источники моделей

Основной источник — Hugging Face Hub (https://huggingface.co/models). Здесь размещены тысячи открытых моделей:

Meta: Llama, Llama2, Llama3
Mistral AI: Mistral, Mixtral, Ministral
Google: Gemma, Gemma2
Microsoft: Phi-3, Phi-4
Alibaba: Qwen
DeepSeek: Deepseek-Coder, Deepseek-MoE
NVIDIA: Nemotron
IBM: Granite
THUDM: GLM

Фильтруйте по лицензии (MIT, Apache 2.0 — разрешено коммерческое использование), количеству параметров и задаче (chat, code, reasoning).

Форматы файлов

GGUF — бинарный формат, оптимизированный для llama.cpp. Поддерживает квантование. Используется в LM Studio, Ollama, Jan.
safetensors — безопасный формат от Hugging Face, без выполнения кода при загрузке.
PyTorch (.bin) — стандартный формат для обучения и тонкой настройки.

Инструменты для запуска

Инструмент	Описание	Особенности
Ollama	Простой CLI и REST API	Автоматическая загрузка, поддержка чат-интерфейса, Docker
LM Studio	Графический интерфейс + сервер	Поддержка GGUF, чат, настройка параметров, RAG
Jan	Десктопное приложение с открытым исходным кодом	Похоже на ChatGPT, поддержка локальных моделей
llama.cpp	Высокопроизводительная C++ библиотека	Минимальные зависимости, GPU-ускорение, CLI
LocalAI	OpenAI-совместимый сервер	Можно подключать как замену `openai.ChatCompletion`
Text Generation WebUI	Веб-интерфейс с множеством функций	Поддержка LoRA, переключение моделей, расширенные параметры

Пример установки через Ollama:

ollama pull llama3:8b-instruct-q5_K_M
ollama run llama3

Чат-интерфейс и параметры генерации

Основные параметры

Параметр	Описание	Типичные значения
Temperature	Креативность / случайность	0.1 (точно) – 1.0 (креативно)
Top-p (nucleus sampling)	Процент наиболее вероятных токенов для выбора	0.9 – 0.95
Max tokens	Максимальная длина ответа	256 – 2048
Repetition penalty	Штраф за повторение	1.0 – 1.2
Presence penalty	Штраф за повторение тем	0.0 – 0.5

Низкая температура (0.1–0.3) — предсказуемые, фактические ответы. Подходит для технических вопросов, кода.
Высокая температура (0.7–1.0) — креативные, разнообразные ответы. Подходит для генерации историй, идей.

Пример настройки в коде (через `llama-cpp-python`)

from llama_cpp import Llama

llm = Llama(
    model_path="models/llama-3-8b.Q5_K_M.gguf",
    n_ctx=8192,
    n_gpu_layers=35,
    verbose=False
)

output = llm(
    "Объясни, как работает HTTP-запрос.",
    max_tokens=512,
    temperature=0.3,
    top_p=0.9,
    repeat_penalty=1.1
)
print(output["choices"][0]["text"])

Интеграция с кодом

Библиотеки

llama-cpp-python — Python-обёртка над llama.cpp. Поддерживает GPU, streaming, функции.
transformers (Hugging Face) — универсальная библиотека для загрузки и запуска моделей (требует больше RAM).
unsloth — оптимизированная версия transformers для быстрого fine-tuning.
vLLM — высокопроизводительный сервер для обслуживания моделей.

Запуск модели как OpenAI-совместимого API

С помощью LocalAI или Ollama можно создать эндпоинт, совместимый с openai SDK:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",  # Ollama
    api_key="ollama"
)

response = client.chat.completions.create(
    model="llama3",
    messages=[{"role": "user", "content": "Напиши функцию на Python для сортировки списка."}]
)
print(response.choices[0].message.content)

Это позволяет использовать существующий код без изменений.

Подходы к работе с ИИ-моделями

Существует три основных подхода к использованию больших языковых моделей (LLM) в практических задачах: использование готовой модели, дообучение (fine-tuning) и RAG (Retrieval-Augmented Generation). Каждый из них решает разные задачи, требует разных ресурсов и подходит для разных сценариев.

Готовая модель без обучения

Это самый простой и распространённый способ. Модель используется «как есть» — без изменения её весов или структуры. Пользователь формулирует запрос, модель генерирует ответ на основе внутренних знаний, заложенных при предварительном обучении.

Преимущества:

Минимальные требования к оборудованию
Быстрое внедрение
Не требуется набор обучающих данных
Подходит для общих задач: чат, написание кода, суммаризация, перевод

Ограничения:

Нет специализированных знаний (например, о вашем продукте, внутренней документации, терминологии)
Ответы могут быть неточными в узких предметных областях
Сложно контролировать формат вывода

Типичные инструменты: Ollama, LM Studio, Jan, llama.cpp, Hugging Face Transformers (в режиме inference)

Дообучение (Fine-tuning)

Дообучение — это процесс дополнительного обучения предварительно обученной модели на специализированном наборе данных. Веса модели изменяются, чтобы она лучше соответствовала вашей предметной области, стилю или формату вывода.

Когда применяется:

Требуется строгий контроль над стилем ответа (например, техническая документация в корпоративном стиле)
Нужна поддержка узкоспециализированной терминологии
Задача требует специфического формата (JSON, XML, таблицы)
Модель должна имитировать поведение конкретного эксперта

Требования:

GPU с 24+ ГБ видеопамяти (RTX 3090/4090, A100 и выше)
Набор качественных пар «ввод → ожидаемый вывод» (обычно от 100 до нескольких тысяч примеров)
Время: от нескольких часов до нескольких дней
Опыт в машинном обучении

Методы дообучения:

Full fine-tuning — обновление всех параметров модели. Требует много памяти.
LoRA (Low-Rank Adaptation) — обучение небольших адаптеров, которые добавляются к исходной модели. Экономит память и время.
QLoRA — LoRA поверх квантованной модели. Позволяет дообучать 7B–13B модели даже на 16 ГБ VRAM.

Инструменты: Unsloth, Hugging Face PEFT, Axolotl, transformers + bitsandbytes

RAG — генерация с внешним контекстом

RAG (Retrieval-Augmented Generation) — это архитектурный паттерн, при котором модель не хранит все знания внутри себя, а динамически извлекает релевантную информацию из внешнего источника (например, вашей документации) и использует её для генерации ответа.

Как это работает:

Пользователь задаёт вопрос.
Система преобразует вопрос в эмбеддинг (векторное представление).
По этому эмбеддингу выполняется поиск по векторной базе данных, содержащей заранее проиндексированные фрагменты ваших документов.
Наиболее релевантные фрагменты (чанки) добавляются в промпт как контекст.
Модель генерирует ответ, опираясь на этот контекст.

Преимущества:

Не требуется переобучение модели
Можно обновлять знания, просто обновляя документы в базе
Ответы точны и актуальны
Работает даже с небольшими моделями (3B–7B)

Ресурсы:

Умеренные: CPU или GPU с 8+ ГБ VRAM
Достаточно одного запуска индексации
Подходит для локального развёртывания

Идеально для:

Чат-ботов по внутренней документации
Анализа кодовой базы проекта
Ответов на вопросы по учебным материалам
Поиска по технической базе знаний

RAG-система поверх локальной модели

Рассмотрим пошагово, как создать систему, которая отвечает на вопросы по вашему проекту, используя только локальные ресурсы.

Шаг 1. Подготовка файлов проекта

Предположим, у вас есть папка my_project/ с исходным кодом, README, документацией в Markdown и конфигурационными файлами.

Цель — позволить модели отвечать на вопросы вроде:

«Как инициализируется подключение к базе данных в этом проекте?»

Шаг 2. Индексация документов

Для этого потребуется:

Разбить документы на чанки (фрагменты текста)
Преобразовать каждый чанк в эмбеддинг с помощью локальной модели векторизации
Сохранить эмбеддинги и исходные тексты в векторное хранилище

Что такое чанк?

Чанк — это фрагмент текста фиксированного или переменного размера. Например:

Размер: 512 токенов
Перекрытие (overlap): 50 токенов (чтобы не разрывать смысл на границе)

Overlap помогает сохранить контекст между соседними чанками.

Какие модели использовать для эмбеддингов?

Локальные модели векторизации:

sentence-transformers/all-MiniLM-L6-v2 — лёгкая, быстрая, хороша для общих задач
BAAI/bge-m3 — более мощная, поддерживает мультиязычность и гибридный поиск
nomic-ai/nomic-embed-text-v1.5 — высокое качество, открытая лицензия

Все они работают через библиотеку sentence-transformers.

Пример скрипта индексации (`index.py`):

import os
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import DirectoryLoader
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma

# Загрузка документов из папки
loader = DirectoryLoader("my_project/", glob="**/*.md", show_progress=True)
docs = loader.load()

# Разбиение на чанки
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,
    chunk_overlap=50,
    length_function=len,
)
chunks = text_splitter.split_documents(docs)

# Локальная модель эмбеддингов
embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2",
    model_kwargs={"device": "cuda"},  # или "cpu"
)

# Создание и сохранение векторного хранилища
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db"
)
vectorstore.persist()
print("Индексация завершена. База сохранена в ./chroma_db")

Запуск:

python index.py

После этого в папке ./chroma_db появится векторная база данных.

Шаг 3. Запуск модели в режиме сервера

Используем LM Studio, так как он предоставляет OpenAI-совместимый API.

Скачайте LM Studio (https://lmstudio.ai/)
Загрузите модель, например Llama-3-8B-Instruct-Q5_K_M.gguf
Перейдите во вкладку Local Server
Нажмите Start Server (по умолчанию: http://localhost:1234/v1)

Теперь вы можете обращаться к модели через стандартный openai SDK.

Шаг 4. RAG-запрос к модели

Создадим скрипт rag_query.py:

from openai import OpenAI
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings

# Подключение к векторной базе
embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2",
    model_kwargs={"device": "cuda"}
)
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=embeddings
)

# Поиск релевантных фрагментов
query = "Как настроить подключение к PostgreSQL?"
retrieved = vectorstore.similarity_search(query, k=3)
context = "\n\n".join([doc.page_content for doc in retrieved])

# Формирование промпта
prompt = f"""Ответь на вопрос, используя только предоставленный контекст.
Если в контексте нет нужной информации, скажи: "Я не знаю".

Контекст:
{context}

Вопрос: {query}
Ответ:"""

# Запрос к локальной модели через OpenAI-совместимый API
client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")
response = client.chat.completions.create(
    model="llama3",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2,  # низкая температура для точности
    max_tokens=512
)

print(response.choices[0].message.content)

Запуск:

python rag_query.py

Результат — точный, контекстуальный ответ, основанный на ваших документах.

Параметры генерации и их влияние

Температура (Temperature)

Температура управляет степенью случайности при выборе следующего токена.

0.1–0.3 — детерминированные, фактические ответы. Подходит для технических вопросов, кода, анализа.
0.5–0.7 — баланс между точностью и креативностью.
0.8–1.0 — разнообразные, творческие, но менее предсказуемые ответы.

Для RAG-систем рекомендуется низкая температура (0.1–0.3), чтобы модель строго следовала контексту.

Top-p (Nucleus Sampling)

Top-p ограничивает выбор токенов до минимального множества, суммарная вероятность которого ≥ p.

0.9 — стандартное значение, сохраняет разнообразие, но отсекает маловероятные варианты.
0.95–1.0 — больше креативности, но выше риск ошибок.

Max Tokens

Ограничивает длину генерируемого ответа. Для технических задач достаточно 256–512 токенов.

Repetition Penalty

Штраф за повторение одних и тех же токенов. Значения:

1.0 — без штрафа
1.1–1.2 — умеренный штраф, предотвращает зацикливание

Интеграция в приложения

Локальные модели можно интегрировать в любые приложения:

Десктоп: через llama-cpp-python или вызов CLI-утилит
Веб: запустить llama.cpp как HTTP-сервер или использовать LocalAI
Мобильные: через ONNX-модели или специализированные движки (MLC LLM)
Автоматизация: скрипты на Python, PowerShell, Bash

Пример: автоматическая генерация changelog на основе коммитов в Git.

Готовая модель, fine-tuning, RAG

Выбор подхода зависит от задачи, доступных ресурсов и требований к точности.

Критерий	Готовая модель	Fine-tuning	RAG
Требования к оборудованию	Минимальные (CPU или GPU с 6+ ГБ VRAM)	Высокие (GPU с 24+ ГБ VRAM, много RAM)	Умеренные (CPU или GPU с 8+ ГБ VRAM)
Время внедрения	Минуты–часы	Дни–недели	Часы–дни
Необходимость данных	Не требуется	Требуется набор пар «ввод → ожидаемый вывод»	Требуется база знаний в виде документов
Обновление знаний	Невозможно без замены модели	Требует повторного обучения	Просто обновить документы и пересоздать индекс
Контроль над ответом	Ограниченный	Высокий (стиль, формат, терминология)	Средний (зависит от качества контекста)
Идеальный сценарий	Общие вопросы, код, перевод	Корпоративный стиль, специфические форматы	Внутренняя документация, техническая поддержка

Для большинства локальных применений RAG — оптимальный выбор: он сочетает гибкость, точность и низкие требования к оборудованию.

Инструменты для локальной работы с моделями

Hugging Face и HF Inference Endpoints

Hugging Face Hub — центральный репозиторий открытых моделей. Большинство современных LLM там представлены в нескольких форматах: PyTorch, safetensors, GGUF.

HF Inference Endpoints — облачный сервис для развёртывания моделей с платной подпиской. Подходит, если нет локального GPU, но требует интернета и оплаты.

Для локальной работы используются:

transformers — загрузка и запуск моделей в PyTorch/TensorFlow
sentence-transformers — эмбеддинги для RAG
accelerate, bitsandbytes — квантование и ускорение на GPU

llama.cpp и llama-cpp-python

llama.cpp — реализация Llama-совместимых моделей на C++ с поддержкой CPU и GPU (через CUDA/Metal). Минимальные зависимости, высокая производительность на CPU.

llama-cpp-python — Python-обёртка, позволяющая легко интегрировать модель в скрипты, веб-приложения, RAG-системы.

Преимущества:

Поддержка GGUF-формата
Возможность частичной загрузки на GPU (n_gpu_layers)
Streaming-генерация
Совместимость с OpenAI API через LocalAI

LM Studio

Графическое приложение для Windows/macOS/Linux. Позволяет:

Искать и скачивать модели из Hugging Face
Запускать чат-интерфейс
Настройку параметров генерации
Запуск OpenAI-совместимого сервера (http://localhost:1234/v1)

Идеально для быстрого прототипирования и тестирования.

Ollama

Кроссплатформенный CLI-инструмент с простым синтаксисом:

ollama run llama3 "Объясни HTTP"

Поддерживает:

Автоматическую загрузку моделей
Создание пользовательских моделей через Modelfile
REST API (http://localhost:11434/api/generate)
Docker-образы

Jan, Unsloth, Pi, Jellybox, Lemonade

Jan — десктопный клиент с открытым исходным кодом, похож на ChatGPT.
Unsloth — библиотека для ускоренного fine-tuning (до 2x быстрее).
Pi, Jellybox, Lemonade — экспериментальные интерфейсы, часто с фокусом на UX или мобильность.

Docker и Runner

Многие инструменты (LocalAI, Ollama, Text Generation WebUI) предоставляют официальные Docker-образы. Это упрощает развёртывание в изолированной среде.

Пример:

FROM ollama/ollama
COPY . /models
RUN ollama create my-model -f ./Modelfile
EXPOSE 11434

Выбор модели

Открытые модели не являются прямой альтернативой GPT-4, но многие из них конкурируют с GPT-3.5.

Модель	Автор	Особенности	Рекомендации
Llama 3 (8B, 70B)	Meta	Отличное качество, поддержка 8K контекста, MIT лицензия	Универсальный выбор для большинства задач
Mistral / Mixtral	Mistral AI	Высокая эффективность, 32K контекст, MoE-архитектура	Для сложных рассуждений и длинных документов
Qwen	Alibaba	Поддержка мультиязычности, сильна в коде	Для международных проектов
Gemma	Google	Лёгкие модели (2B, 7B), Apache 2.0	Для устройств с ограничениями по памяти
Phi-3	Microsoft	Компактная (3.8B), но мощная, оптимизирована под CPU	Для мобильных и edge-устройств
Deepseek-Coder	DeepSeek	Специализирована на генерации кода	Для разработчиков
Nemotron	NVIDIA	Оптимизирована для enterprise-сценариев	Для корпоративного использования
Granite	IBM	Фокус на безопасность и соответствие стандартам	Для регулируемых отраслей

Совет: начинайте с Llama-3-8B-Instruct или Mistral-7B-Instruct — они дают лучшее соотношение качества и ресурсов.

LangChain

LangChain — это набор инструментов для построения приложений поверх LLM. Он абстрагирует взаимодействие с моделями, векторными хранилищами, инструментами и памятью.

Основные компоненты:

LLM — обёртка над моделью (Ollama, LlamaCpp, HuggingFace)
Embeddings — генерация эмбеддингов (HuggingFaceEmbeddings, OllamaEmbeddings)
VectorStore — работа с Chroma, FAISS, Pinecone
Retriever — поиск релевантных чанков
Chain — цепочка операций (например, RAG Chain)
Agent — система, которая может вызывать инструменты на основе промпта

Пример RAG-цепочки:

from langchain.chains import RetrievalQA
from langchain_community.llms import Ollama
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings

llm = Ollama(model="llama3")
embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
    chain_type="stuff"
)

response = qa_chain.invoke("Как работает авторизация в этом проекте?")
print(response["result"])

LangChain упрощает создание сложных систем, но добавляет зависимостей. Для простых случаев достаточно напрямую использовать llama-cpp-python и Chroma.

ChromaDB и sentence-transformers

sentence-transformers

Библиотека от SBERT.net для генерации эмбеддингов из текста. Работает на CPU/GPU, поддерживает сотни моделей.

ChromaDB

Лёгкое векторное хранилище, работающее в памяти или на диске. Не требует отдельного сервера.

Особенности:

Автоматическое сохранение на диск (persist_directory)
Поддержка метаданных (источник файла, дата и т.д.)
Встроенный similarity search
Совместимость с LangChain

Индексация занимает от нескольких секунд (для 100 KB текста) до минут (для больших кодовых баз).